#define _POSIX_C_SOURCE 200809L
/**
 * @file protocol_transport.c
 * @brief 协议传输适配器实现
 * @details 本文件实现了协议层与传输层的适配器，使104协议能够使用
 *          统一的传输抽象层，支持多种传输方式。实现协议传输的创建、
 *          连接、断开、发送、接收等核心功能。
 * 
 * @author zyb
 * @date 2025-10-20
 * @version 1.0
 */

#include "../include/protocol_transport.h"
#include "../../common/types/include/protocol_types.h"
#include "../../common/error/include/error_codes.h"
#include "../../protocol/apdu/include/apdu_parser.h"
#include "../../protocol/apdu/include/apdu_assembler.h"
#include "../../../../../common/logs/include/logger.h"
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>

// 定义模块名称
#define LOG_MODULE_NAME "PROTOCOL_TRANSPORT"

/* ==================== 协议传输私有数据结构 ==================== */

/**
 * @brief 协议传输私有数据
 */
typedef struct {
    protocol_transport_config_t config;     /* 协议传输配置 */
    protocol_transport_state_t state;       /* 协议传输状态 */
    protocol_transport_stats_t stats;       /* 协议传输统计 */
    
    /* 传输层接口 */
    void* net_transport_handle; /* 网络传输驱动句柄 */
    
    /* 回调函数 */
    protocol_apdu_receive_callback_t apdu_callback;
    void* apdu_user_data;
    protocol_transport_state_callback_t state_callback;
    void* state_user_data;
    protocol_error_callback_t error_callback;
    void* error_user_data;
    
    /* 线程相关 */
    pthread_t receive_thread;               /* 接收线程 */
    bool thread_running;                    /* 线程运行标志 */
    pthread_mutex_t mutex;                  /* 互斥锁 */
} protocol_transport_private_t;

/* ==================== 内部函数声明 ==================== */

static void protocol_transport_handle_receive_data(const uint8_t* data, size_t length, void* user_data);
static void protocol_transport_handle_status_change(net_transport_status_t status, void* user_data);
static void protocol_transport_handle_error(net_transport_error_t error, void* user_data);
static void* protocol_transport_receive_thread(void* arg);
// static protocol_error_t protocol_transport_validate_config(const protocol_transport_config_t* config);

/* ==================== 协议传输创建和销毁 ==================== */

/**
 * @brief 创建协议传输实例
 * @details 创建协议传输实例，初始化传输层驱动
 * 
 * @param config 协议传输配置
 * @return 协议传输句柄，失败返回NULL
 */
protocol_transport_handle_t protocol_transport_create(const protocol_transport_config_t* config) {
    if (config == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "配置参数为空");
        return NULL;
    }
    
    // 验证配置
    protocol_error_t validation_result = protocol_transport_validate_config(config);
    if (validation_result != PROTOCOL_SUCCESS) {
        LOG_ERROR(LOG_MODULE_NAME, "配置验证失败: %d", validation_result);
        return NULL;
    }
    
    // 分配私有数据结构
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)malloc(sizeof(protocol_transport_private_t));
    if (private_data == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "内存分配失败");
        return NULL;
    }
    
    // 初始化私有数据
    memset(private_data, 0, sizeof(protocol_transport_private_t));
    private_data->config = *config;
    private_data->state = PROTOCOL_TRANSPORT_STATE_IDLE;
    
    // 初始化互斥锁
    if (pthread_mutex_init(&private_data->mutex, NULL) != 0) {
        LOG_ERROR(LOG_MODULE_NAME, "互斥锁初始化失败");
        free(private_data);
        return NULL;
    }
    
    // 创建网络传输驱动实例
    private_data->net_transport_handle = transport_net_create(&config->transport_config);
    if (private_data->net_transport_handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "创建网络传输驱动失败");
        pthread_mutex_destroy(&private_data->mutex);
        free(private_data);
        return NULL;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "创建网络传输驱动实例成功: %p", private_data->net_transport_handle);
    
    // 设置回调函数
    transport_net_set_receive_callback(private_data->net_transport_handle,
                                       protocol_transport_handle_receive_data,
                                          private_data);
    
    transport_net_set_status_callback(private_data->net_transport_handle,
                                      protocol_transport_handle_status_change,
                                      private_data);
    
    transport_net_set_error_callback(private_data->net_transport_handle,
                                     protocol_transport_handle_error,
                                     private_data);
    
    LOG_INFO(LOG_MODULE_NAME, "协议传输实例创建成功，超时时间: %u ms", config->protocol_timeout);
    
    return (protocol_transport_handle_t)private_data;
}

/**
 * @brief 销毁协议传输实例
 * @details 销毁协议传输实例，清理所有资源
 * 
 * @param handle 协议传输句柄
 * @return 协议错误码
 */
protocol_error_t protocol_transport_destroy(protocol_transport_handle_t handle) {
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "句柄为空");
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)handle;
    
    // 停止接收线程
    if (private_data->thread_running) {
        private_data->thread_running = false;
        pthread_join(private_data->receive_thread, NULL);
    }
    
    // 断开连接
    if (private_data->net_transport_handle != NULL) {
        LOG_DEBUG(LOG_MODULE_NAME, "销毁网络传输驱动实例: %p", private_data->net_transport_handle);
        transport_net_destroy(private_data->net_transport_handle);
    }
    
    // 销毁互斥锁
    pthread_mutex_destroy(&private_data->mutex);
    
    // 释放内存
    free(private_data);
    
    LOG_INFO(LOG_MODULE_NAME, "协议传输实例销毁成功");
    return PROTOCOL_SUCCESS;
}

/* ==================== 协议传输连接管理 ==================== */

/**
 * @brief 连接协议传输
 * @details 建立协议传输连接
 * 
 * @param handle 协议传输句柄
 * @return 协议错误码
 */
protocol_error_t protocol_transport_connect(protocol_transport_handle_t handle) {
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "句柄为空");
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    
    if (private_data->state != PROTOCOL_TRANSPORT_STATE_IDLE) {
        LOG_ERROR(LOG_MODULE_NAME, "传输状态错误: %d", private_data->state);
        pthread_mutex_unlock(&private_data->mutex);
        return PROTOCOL_ERROR_INVALID_FORMAT;
    }
    
    private_data->state = PROTOCOL_TRANSPORT_STATE_CONNECTING;
    
    // 连接网络传输驱动
    net_transport_error_t result = transport_net_connect(private_data->net_transport_handle);
    if (result != NET_TRANSPORT_SUCCESS) {
        LOG_ERROR(LOG_MODULE_NAME, "网络传输连接失败: %d", result);
        private_data->state = PROTOCOL_TRANSPORT_STATE_ERROR;
        pthread_mutex_unlock(&private_data->mutex);
        return PROTOCOL_ERROR_PARAM_WRITE_FAILED;
    }
    
    private_data->state = PROTOCOL_TRANSPORT_STATE_CONNECTED;
    
    // 启动接收线程
    private_data->thread_running = true;
    if (pthread_create(&private_data->receive_thread, NULL, protocol_transport_receive_thread, private_data) != 0) {
        LOG_ERROR(LOG_MODULE_NAME, "创建接收线程失败");
        private_data->thread_running = false;
        private_data->state = PROTOCOL_TRANSPORT_STATE_ERROR;
        pthread_mutex_unlock(&private_data->mutex);
        return PROTOCOL_ERROR_SYSTEM_ERROR;
    }
    
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "协议传输连接成功");
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 断开协议传输连接
 * @details 断开协议传输连接
 * 
 * @param handle 协议传输句柄
 * @return 协议错误码
 */
protocol_error_t protocol_transport_disconnect(protocol_transport_handle_t handle) {
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "句柄为空");
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    
    if (private_data->state == PROTOCOL_TRANSPORT_STATE_IDLE) {
        LOG_WARN(LOG_MODULE_NAME, "传输已处于空闲状态");
        pthread_mutex_unlock(&private_data->mutex);
        return PROTOCOL_SUCCESS;
    }
    
    private_data->state = PROTOCOL_TRANSPORT_STATE_DISCONNECTING;
    
    // 停止接收线程
    if (private_data->thread_running) {
        private_data->thread_running = false;
        pthread_mutex_unlock(&private_data->mutex);
        pthread_join(private_data->receive_thread, NULL);
        pthread_mutex_lock(&private_data->mutex);
    }
    
    // 断开网络传输连接
    if (private_data->net_transport_handle != NULL) {
        transport_net_disconnect(private_data->net_transport_handle);
    }
    
    private_data->state = PROTOCOL_TRANSPORT_STATE_IDLE;
    
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "协议传输断开成功");
    return PROTOCOL_SUCCESS;
}

/* ==================== 协议传输数据发送 ==================== */

/**
 * @brief 发送APDU数据
 * @details 通过协议传输发送APDU数据
 * 
 * @param handle 协议传输句柄
 * @param apdu 要发送的APDU
 * @return 协议错误码
 */
protocol_error_t protocol_transport_send_apdu(protocol_transport_handle_t handle, const apdu_t* apdu) {
    if (handle == NULL || apdu == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "参数无效");
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    
    if (private_data->state != PROTOCOL_TRANSPORT_STATE_CONNECTED) {
        LOG_ERROR(LOG_MODULE_NAME, "传输未连接，状态: %d", private_data->state);
        pthread_mutex_unlock(&private_data->mutex);
        return PROTOCOL_ERROR_NOT_CONNECTED;
    }
    
    // 这里需要将APDU转换为字节数据发送
    // 暂时使用简单的实现
    uint8_t* apdu_data = (uint8_t*)apdu;
    size_t apdu_length = sizeof(apdu_t);
    
    // 发送数据
    net_transport_error_t transport_result = transport_net_send(private_data->net_transport_handle,
                                                               apdu_data,
                                                               apdu_length);
    if (transport_result != NET_TRANSPORT_SUCCESS) {
        LOG_ERROR(LOG_MODULE_NAME, "发送数据失败: %d", transport_result);
        private_data->stats.send_errors++;
        pthread_mutex_unlock(&private_data->mutex);
        return PROTOCOL_ERROR_PARAM_WRITE_FAILED;
    }
    
    // 更新统计信息
    private_data->stats.bytes_sent += apdu_length;
    private_data->stats.apdu_sent++;
    
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_DEBUG(LOG_MODULE_NAME, "APDU数据发送成功");
    return PROTOCOL_SUCCESS;
}

/* ==================== 协议传输配置管理 ==================== */

/**
 * @brief 设置协议传输配置
 * @details 设置协议传输配置参数
 * 
 * @param handle 协议传输句柄
 * @param config 新的配置参数
 * @return 协议错误码
 */
protocol_error_t protocol_transport_set_config(protocol_transport_handle_t handle,
                                               const protocol_transport_config_t* config) {
    if (handle == NULL || config == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "参数无效");
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    
    // 验证配置
    protocol_error_t validation_result = protocol_transport_validate_config(config);
    if (validation_result != PROTOCOL_SUCCESS) {
        LOG_ERROR(LOG_MODULE_NAME, "配置验证失败: %d", validation_result);
        pthread_mutex_unlock(&private_data->mutex);
        return validation_result;
    }
    
    // 更新配置
    private_data->config = *config;
            
            pthread_mutex_unlock(&private_data->mutex);
            
    LOG_INFO(LOG_MODULE_NAME, "协议传输配置更新成功，超时时间: %u ms", config->protocol_timeout);
            return PROTOCOL_SUCCESS;
}

/**
 * @brief 获取协议传输配置
 * @details 获取当前协议传输配置参数
 * 
 * @param handle 协议传输句柄
 * @param config 配置参数输出缓冲区
 * @return 协议错误码
 */
protocol_error_t protocol_transport_get_config(protocol_transport_handle_t handle,
                                               protocol_transport_config_t* config) {
    if (handle == NULL || config == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "参数无效");
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    *config = private_data->config;
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "协议传输配置获取成功，超时时间: %u ms", config->protocol_timeout);
    return PROTOCOL_SUCCESS;
}

/* ==================== 协议传输状态管理 ==================== */

/**
 * @brief 获取协议传输状态
 * @details 获取当前协议传输状态
 * 
 * @param handle 协议传输句柄
 * @return 协议传输状态
 */
protocol_transport_state_t protocol_transport_get_state(protocol_transport_handle_t handle) {
    if (handle == NULL) {
        return PROTOCOL_TRANSPORT_STATE_ERROR;
    }
    
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    protocol_transport_state_t state = private_data->state;
    pthread_mutex_unlock(&private_data->mutex);
    
    return state;
}

/**
 * @brief 获取协议传输统计信息
 * @details 获取协议传输统计信息
 * 
 * @param handle 协议传输句柄
 * @param stats 统计信息输出缓冲区
 * @return 协议错误码
 */
protocol_error_t protocol_transport_get_stats(protocol_transport_handle_t handle,
                                              protocol_transport_stats_t* stats) {
    if (handle == NULL || stats == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "参数无效");
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    *stats = private_data->stats;
    pthread_mutex_unlock(&private_data->mutex);
    
    return PROTOCOL_SUCCESS;
}

/* ==================== 协议传输回调函数设置 ==================== */

/**
 * @brief 设置APDU接收回调函数
 * @details 设置APDU数据接收回调函数
 * 
 * @param handle 协议传输句柄
 * @param callback 回调函数
 * @param user_data 用户数据
 * @return 协议错误码
 */
protocol_error_t protocol_transport_set_apdu_callback(protocol_transport_handle_t handle,
                                                      protocol_apdu_receive_callback_t callback,
                                                      void* user_data) {
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "句柄为空");
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    private_data->apdu_callback = callback;
    private_data->apdu_user_data = user_data;
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_DEBUG(LOG_MODULE_NAME, "APDU接收回调函数设置成功");
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 设置状态变化回调函数
 * @details 设置传输状态变化回调函数
 * 
 * @param handle 协议传输句柄
 * @param callback 回调函数
 * @param user_data 用户数据
 * @return 协议错误码
 */
protocol_error_t protocol_transport_set_state_callback(protocol_transport_handle_t handle,
                                                       protocol_transport_state_callback_t callback,
                                                       void* user_data) {
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "句柄为空");
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    private_data->state_callback = callback;
    private_data->state_user_data = user_data;
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_DEBUG(LOG_MODULE_NAME, "状态变化回调函数设置成功");
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 设置错误回调函数
 * @details 设置传输错误回调函数
 * 
 * @param handle 协议传输句柄
 * @param callback 回调函数
 * @param user_data 用户数据
 * @return 协议错误码
 */
protocol_error_t protocol_transport_set_error_callback(protocol_transport_handle_t handle,
                                                       protocol_error_callback_t callback,
                                                       void* user_data) {
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "句柄为空");
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    private_data->error_callback = callback;
    private_data->error_user_data = user_data;
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_DEBUG(LOG_MODULE_NAME, "错误回调函数设置成功");
    return PROTOCOL_SUCCESS;
}

/* ==================== 内部函数实现 ==================== */

/**
 * @brief 处理接收到的数据
 * @details 网络传输驱动接收数据的回调函数
 * 
 * @param data 接收到的数据
 * @param length 数据长度
 * @param user_data 用户数据
 */
static void protocol_transport_handle_receive_data(const uint8_t* data, size_t length, void* user_data) {
    if (data == NULL || length == 0 || user_data == NULL) {
        return;
    }
    
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)user_data;
    
    // 更新统计信息
    pthread_mutex_lock(&private_data->mutex);
    private_data->stats.bytes_received += length;
    private_data->stats.apdu_received++;
    pthread_mutex_unlock(&private_data->mutex);
    
    // 这里需要将接收到的字节数据转换为APDU结构
    // 暂时使用简单的实现
    apdu_t apdu;
    if (length >= sizeof(apdu_t)) {
        memcpy(&apdu, data, sizeof(apdu_t));
        
        // 调用APDU回调函数
        if (private_data->apdu_callback != NULL) {
            private_data->apdu_callback(&apdu, private_data->apdu_user_data);
        }
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "接收到数据，长度: %zu", length);
}

/**
 * @brief 处理状态变化
 * @details 网络传输驱动状态变化的回调函数
 * 
 * @param status 网络传输状态
 * @param user_data 用户数据
 */
static void protocol_transport_handle_status_change(net_transport_status_t status, void* user_data) {
    if (user_data == NULL) {
        return;
    }
    
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)user_data;
    
    // 转换状态
    protocol_transport_state_t protocol_state;
    switch (status) {
        case NET_TRANSPORT_STATUS_DISCONNECTED:
            protocol_state = PROTOCOL_TRANSPORT_STATE_IDLE;
            break;
        case NET_TRANSPORT_STATUS_CONNECTING:
            protocol_state = PROTOCOL_TRANSPORT_STATE_CONNECTING;
            break;
        case NET_TRANSPORT_STATUS_CONNECTED:
            protocol_state = PROTOCOL_TRANSPORT_STATE_CONNECTED;
            break;
        case NET_TRANSPORT_STATUS_DISCONNECTING:
            protocol_state = PROTOCOL_TRANSPORT_STATE_DISCONNECTING;
            break;
        case NET_TRANSPORT_STATUS_ERROR:
        default:
            protocol_state = PROTOCOL_TRANSPORT_STATE_ERROR;
            break;
    }
    
    // 更新状态
    pthread_mutex_lock(&private_data->mutex);
    private_data->state = protocol_state;
    pthread_mutex_unlock(&private_data->mutex);
    
    // 调用状态回调函数
    if (private_data->state_callback != NULL) {
        private_data->state_callback(protocol_state, private_data->state_user_data);
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "传输状态变化: %d", protocol_state);
}

/**
 * @brief 处理错误
 * @details 网络传输驱动错误的回调函数
 * 
 * @param error 网络传输错误
 * @param user_data 用户数据
 */
static void protocol_transport_handle_error(net_transport_error_t error, void* user_data) {
    if (user_data == NULL) {
        return;
    }
    
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)user_data;
    
    // 更新统计信息
    pthread_mutex_lock(&private_data->mutex);
    private_data->stats.receive_errors++;
    private_data->stats.last_error = error;
    private_data->state = PROTOCOL_TRANSPORT_STATE_ERROR;
    pthread_mutex_unlock(&private_data->mutex);
    
    // 转换错误码
    protocol_error_t protocol_error = PROTOCOL_ERROR_PARAM_WRITE_FAILED;
    switch (error) {
        case NET_TRANSPORT_ERROR_TIMEOUT:
            protocol_error = PROTOCOL_ERROR_TIMEOUT;
            break;
        case NET_TRANSPORT_ERROR_NOT_CONNECTED:
            protocol_error = PROTOCOL_ERROR_NOT_CONNECTED;
            break;
        default:
            protocol_error = PROTOCOL_ERROR_PARAM_WRITE_FAILED;
            break;
    }
    
    // 调用错误回调函数
    if (private_data->error_callback != NULL) {
        private_data->error_callback(protocol_error, private_data->error_user_data);
    }
    
    LOG_ERROR(LOG_MODULE_NAME, "传输错误: %d", error);
}

/**
 * @brief 接收线程函数
 * @details 协议传输接收线程，用于处理接收到的数据
 * 
 * @param arg 线程参数
 * @return 线程返回值
 */
static void* protocol_transport_receive_thread(void* arg) {
    protocol_transport_private_t* private_data = (protocol_transport_private_t*)arg;
    
    LOG_DEBUG(LOG_MODULE_NAME, "接收线程启动");
    
    while (private_data->thread_running) {
        // 这里可以添加额外的接收处理逻辑
        // 目前数据接收通过回调函数处理
        
        struct timespec ts = {0, 1000000}; // 1ms
        nanosleep(&ts, NULL);
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "接收线程退出");
    return NULL;
}

/**
 * @brief 验证协议传输配置
 * @details 验证协议传输配置参数的有效性
 * 
 * @param config 配置参数
 * @return 协议错误码
 */
protocol_error_t protocol_transport_validate_config(const protocol_transport_config_t* config) {
    if (config == NULL) {
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    // 验证超时时间
    if (config->protocol_timeout == 0) {
        LOG_ERROR(LOG_MODULE_NAME, "协议超时时间无效: %u", config->protocol_timeout);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    // 验证重试次数
    if (config->retry_count > 10) {
        LOG_ERROR(LOG_MODULE_NAME, "重试次数过大: %u", config->retry_count);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    LOG_INFO(LOG_MODULE_NAME, "协议传输配置验证成功，超时时间: %u ms", config->protocol_timeout);
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 从配置文件加载网络传输配置
 * @details 从配置文件中加载网络传输配置（IP、端口等），并填充到协议传输配置中
 */
protocol_error_t protocol_transport_load_net_config(const char* config_file, protocol_transport_config_t* config) {
    if (config == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "配置参数为空");
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    // 从配置文件加载网络传输配置
    net_transport_error_t net_result = transport_net_config_load(config_file, &config->transport_config);
    if (net_result != NET_TRANSPORT_SUCCESS) {
        LOG_ERROR(LOG_MODULE_NAME, "加载网络传输配置失败: %d", net_result);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    LOG_INFO(LOG_MODULE_NAME, "从配置文件加载网络传输配置成功: %s:%u", 
             config->transport_config.server_ip, config->transport_config.server_port);
    
    return PROTOCOL_SUCCESS;
}

/* ==================== 工具函数 ==================== */

/**
 * @brief 获取传输类型名称
 * @details 根据传输类型获取对应的名称字符串
 * 
 * @param type 传输类型
 * @return 传输类型名称字符串
 */
const char* protocol_transport_get_type_name(int type) {
    (void)type; // 抑制未使用参数警告
    return "NET_TRANSPORT";
}

/**
 * @brief 获取协议传输状态名称
 * @details 获取协议传输状态的可读名称
 * 
 * @param state 协议传输状态
 * @return 状态名称字符串
 */
const char* protocol_transport_get_state_name(protocol_transport_state_t state) {
    switch (state) {
        case PROTOCOL_TRANSPORT_STATE_IDLE:
            return "IDLE";
        case PROTOCOL_TRANSPORT_STATE_CONNECTING:
            return "CONNECTING";
        case PROTOCOL_TRANSPORT_STATE_CONNECTED:
            return "CONNECTED";
        case PROTOCOL_TRANSPORT_STATE_DISCONNECTING:
            return "DISCONNECTING";
        case PROTOCOL_TRANSPORT_STATE_ERROR:
            return "ERROR";
        default:
            return "UNKNOWN";
    }
}